using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.AI;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System.IO;

public class Wei_ZhuGong : MonoBehaviour
{
    // 将军基本属性
    public string generalName = "曹操";
    public int health = 100;
    // 是否正在战斗
    public bool is_attacking = false;
    // 是否到达目的地
    public bool is_arrive = false;
    // 所属国家
    public string country = "Wei";
    // 士兵数量
    public int archerAccount;    // 弓箭手数量
    public int infantryAccount;  // 步兵数量
    public int cavalryAccount;  // 骑兵数量

    // 当前所在区域坐标
    public string currentPosition;
    // 目标区域坐标（目标位置对象的名称）
    public string targetPosition;
    // 阵型
    public string formation;
    // 活动
    public string activity;

    [Header("移动设置")]
    public float speed = 1f;                    // 移动速度
    NavMeshAgent agent;

    [Header("个体设置")]
    public int attackPower = 5;                 // 每次攻击伤害值
    [Header("目的地设置")]
    public float arrivalDistance = 2f;         // 接近目的地的距离阈值，小于该值视为到达

    [Header("动画设置")]
    private Animator anim;                      // Animator 组件
    private Dictionary<string, string> recallMessage1 = new Dictionary<string, string>
    {
        {"谁", "曹操"},
        {"带多少兵", "0,0,0"}, // 设置为0表示没有兵力
        {"去什么地方", ""}, // 初始不设置目的地
        {"以什么策略", "方阵"},
        {"干什么事", "Defend"}
    };

    // 决策文件路径
    private string decisionFolderPath;
    private string caoCaoDecisionPath;

    // 上次处理的决策时间
    private DateTime lastProcessedTime = DateTime.MinValue;

    [Header("决策内容")]
    public string lastDecisionJson; // 最后一次决策的JSON内容
    public string lastDecisionTime; // 最后一次决策的时间

    public Stack<Dictionary<string, string>> stackPrivate = new Stack<Dictionary<string, string>>();

    private enum State { Idle, Attack, Defend, Withdraw, Dying };
    private State currentState = State.Idle;
    [Header("状态机状态")]
    public string currentStateString = "空闲"; // 用于在Inspector中显示当前状态
    private AnimationController _animationController;

    [Header("敌人检测与攻击")]
    public float detectionRange = 5f;           // 敌人检测范围
    public float attackRange = 1f;              // 攻击范围
    public float attackCooldown = 1f;           // 攻击冷却时间
    private float lastAttackTime = 0f;          // 上次攻击时间
    private Transform enemyTransform;           // 当前目标敌人
    private float checkEnemyInterval = 0.5f;    // 检查敌人的时间间隔

    private Vector2 currentDirection = Vector2.zero;  // 当前移动方向
    private FormationManager _formationManager;

    // Start is called before the first frame update
    void Start()
    {
        // 初始化观察变量
        formation = "方阵";
        currentPosition = transform.position.ToString();
        archerAccount = 0; // 初始没有士兵
        infantryAccount = 0;
        cavalryAccount = 0;

        stackPrivate.Push(recallMessage1);
        anim = GetComponent<Animator>();
        _animationController = new AnimationController(GetComponent<Animator>());
        agent = GetComponent<NavMeshAgent>();
        agent.updateRotation = false;
        agent.updateUpAxis = false;
        agent.speed = speed;  // 设置移动速度
        agent.isStopped = false;  // 确保初始状态不是停止的

        // 设置决策文件路径
        decisionFolderPath = Path.Combine(Application.dataPath, "Scripts/Wu_test/Wei/Wei_Decision");
        caoCaoDecisionPath = Path.Combine(decisionFolderPath, "decision_4.json"); // 曹操的决策编号为3

        Debug.Log($"【曹操】将从文件路径监视决策: {caoCaoDecisionPath}");

        // 启动状态机和文件监视协程
        StartCoroutine(StateMachine());
        StartCoroutine(CheckDecisionFileRoutine());
        // 启动敌人检测协程
        StartCoroutine(DetectEnemies());
    }

    void Update()
    {
        if(health <= 0)
        {
            Destroy(gameObject);
            // 销毁其他将军
            GameObject[] generals = GameObject.FindGameObjectsWithTag("Wei_General");
            foreach (GameObject general in generals)
            {
                Destroy(general);
            }
            // 销毁侦察兵
            GameObject[] scouts = GameObject.FindGameObjectsWithTag("Wei_Scout");
            foreach (GameObject scout in scouts)
            {
                Destroy(scout);
            }
        }
    }

    // 定期检查决策文件
    private IEnumerator CheckDecisionFileRoutine()
    {
        Debug.Log("【曹操】启动决策文件监视协程");

        while (true)
        {
            // 检查曹操决策文件是否存在并且已更新
            if (File.Exists(caoCaoDecisionPath))
            {
                DateTime lastWriteTime = File.GetLastWriteTime(caoCaoDecisionPath);

                // 如果文件比上次处理的新
                if (lastWriteTime > lastProcessedTime)
                {
                    Debug.Log($"【曹操】发现新的决策文件，上次处理时间: {lastProcessedTime}，文件更新时间: {lastWriteTime}");
                    LoadDecisionFromFile();
                    lastProcessedTime = lastWriteTime;
                }
            }

            // 每秒检查一次
            yield return new WaitForSeconds(1f);
        }
    }

    // 从文件中加载曹操的决策
    private void LoadDecisionFromFile()
    {
        try
        {
            // 读取文件内容
            string jsonContent = File.ReadAllText(caoCaoDecisionPath);
            Debug.Log($"【曹操】读取到决策文件内容: {jsonContent.Substring(0, Mathf.Min(100, jsonContent.Length))}...");

            // 保存原始JSON内容用于观察
            lastDecisionJson = jsonContent;
            lastDecisionTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");

            // 解析JSON
            JObject decisionObj = JObject.Parse(jsonContent);

            // 创建命令字典
            Dictionary<string, string> caoCaoCommand = new Dictionary<string, string>();

            // 提取各项命令属性
            caoCaoCommand["谁"] = "曹操";
            caoCaoCommand["带多少兵"] = decisionObj["带领多少士兵(how many)"]?.ToString() ?? "5,5,5";
            caoCaoCommand["去什么地方"] = decisionObj["去到哪个地方(where)"]?.ToString() ?? "当前位置";
            caoCaoCommand["以什么策略"] = decisionObj["阵型"]?.ToString() ?? "方阵";

            // 将行为映射到内部使用的行为名称
            string action = decisionObj["行为"]?.ToString() ?? "待命";
            caoCaoCommand["干什么事"] = MapActionToCommand(action);

            Debug.Log($"【曹操】成功解析决策: 去往{caoCaoCommand["去什么地方"]}, 行为:{caoCaoCommand["干什么事"]}, 阵型:{caoCaoCommand["以什么策略"]}, 兵力:{caoCaoCommand["带多少兵"]}");

            // 清空原有命令并添加新命令
            stackPrivate.Clear();
            stackPrivate.Push(caoCaoCommand);

            // 更新当前行为和相关变量以便于观察
            activity = MapActionToCaoCaoActivity(caoCaoCommand["干什么事"]);
            formation = caoCaoCommand["以什么策略"];
            targetPosition = caoCaoCommand["去什么地方"];

            // 立即应用目标位置
            UpdateTargetPosition(targetPosition);

            // 解析兵力配置并更新
            string[] troops = caoCaoCommand["带多少兵"].Split(',');
            if (troops.Length == 3)
            {
                int.TryParse(troops[0], out cavalryAccount);
                int.TryParse(troops[1], out archerAccount);
                int.TryParse(troops[2], out infantryAccount);
            }

            Debug.Log($"【曹操】新命令已添加到队列，当前活动: {activity}，目标: {targetPosition}，阵型: {formation}，兵力: 骑兵{cavalryAccount},弓兵{archerAccount},步兵{infantryAccount}");
        }
        catch (Exception e)
        {
            Debug.LogError($"【曹操】读取决策文件时出错: {e.Message}");
        }
    }

    // 添加一个新方法用于更新目标位置
    private void UpdateTargetPosition(string destination)
    {
        if (string.IsNullOrEmpty(destination) || destination == "当前位置")
        {
            Debug.Log("【曹操】目标位置为当前位置，不移动");
            return;
        }

        GameObject destinationObj = GameObject.Find(destination);
        if (destinationObj != null)
        {
            Debug.Log($"【曹操】立即更新目标位置为: {destination}，坐标: {destinationObj.transform.position}");
            // 重置到达状态
            is_arrive = false;

            // 确保NavMeshAgent可用
            if (agent != null && agent.isActiveAndEnabled)
            {
                // 先停止当前移动
                agent.isStopped = true;
                agent.velocity = Vector3.zero;

                // 设置新的目标位置
                agent.SetDestination(destinationObj.transform.position);

                // 确保代理可以移动
                agent.isStopped = false;

                // 启动移动动画更新协程
                StopCoroutine("UpdateMovementAnimation");
                StartCoroutine("UpdateMovementAnimation");

                Debug.Log($"【曹操】立即设置导航目标为: {destination}，坐标: {destinationObj.transform.position}");
            }
            else
            {
                Debug.LogError("【曹操】NavMeshAgent不可用，无法设置目标位置");
            }
        }
        else
        {
            Debug.LogError($"【曹操】未找到目标位置对象: {destination}");
        }
    }

    // 添加新的移动动画更新协程
    private IEnumerator UpdateMovementAnimation()
    {
        while (!is_arrive && agent != null && agent.isActiveAndEnabled)
        {
            // 获取当前速度并更新动画
            Vector2 velocity = new Vector2(agent.velocity.x, agent.velocity.y);
            if (velocity.magnitude > 0.1f)
            {
                _animationController.SetMovement(velocity.normalized);
            }
            else
            {
                _animationController.SetMovement(Vector2.zero);
            }
            
            yield return new WaitForSeconds(0.05f);
        }
    }

    // 将AI生成的行为映射到内部使用的命令
    private string MapActionToCommand(string aiAction)
    {
        switch (aiAction)
        {
            case "进攻":
                is_attacking = false; // 重置攻击状态
                return "Attack";
            case "防守":
                is_attacking = false; // 重置攻击状态
                return "Defend";
            case "撤退":
                is_attacking = false; // 重置攻击状态
                return "Withdraw";
            case "支援":
                is_attacking = false; // 重置攻击状态
                return "Support";
            default:
                is_attacking = false; // 重置攻击状态
                return "Attack";  // 默认行为
        }
    }

    // 将内部命令映射到activity属性
    private string MapActionToCaoCaoActivity(string command)
    {
        switch (command)
        {
            case "Attack": return "进攻";
            case "Defend": return "防守";
            case "Withdraw": return "撤退";
            case "Support": return "支援";
            default: return "待命";
        }
    }

    // 状态机协程
    IEnumerator StateMachine()
    {
        while (true)
        {
            switch (currentState)
            {
                case State.Idle:
                    currentStateString = "空闲";
                    yield return IdleState();
                    break;

                case State.Attack:
                    currentStateString = "进攻";
                    yield return AttackState();
                    break;

                case State.Defend:
                    currentStateString = "防守";
                    yield return DefendState();
                    break;

                case State.Withdraw:
                    currentStateString = "撤退";
                    yield return WithdrawState();
                    break;
            }
            yield return null;  // 确保每个状态之间有一次休息
        }
    }

    private IEnumerator IdleState()
    {
        if (stackPrivate.Count > 0)
        {
            Debug.Log("处理新的报文");
            // 获取并处理最新的报文
            Dictionary<string, string> currentMessage = stackPrivate.Pop();

            // 处理兵力配置
            string[] troops = currentMessage["带多少兵"].Split(',');
            Debug.Log($"解析兵力配置: {currentMessage["带多少兵"]}");

            // if (troops.Length == 3)
            // {
            //     // 生成骑兵
            //     GameObject cavalryPrefab = Resources.Load<GameObject>("ShiBing");
            //     Debug.Log(cavalryPrefab != null ? "成功加载骑兵预制体" : "未找到骑兵预制体");

            //     if (cavalryPrefab != null && int.TryParse(troops[0], out int cavalryCount))
            //     {
            //         _formationManager = new FormationManager(cavalryPrefab, transform.position + new Vector3(-2f, 0, 0));
            //         _formationManager.SetFormationType(FormationManager.FormationType.Box);
            //         _formationManager.SetBoxParameters(cavalryCount, 1, false);
            //         _formationManager.UpdateFormation();
            //         Debug.Log($"生成 {cavalryCount} 个骑兵");
            //     }

            //     // 生成射手
            //     GameObject archerPrefab = Resources.Load<GameObject>("ShiBing");
            //     Debug.Log(archerPrefab != null ? "成功加载射手预制体" : "未找到射手预制体");

            //     if (archerPrefab != null && int.TryParse(troops[1], out int archerCount))
            //     {
            //         _formationManager = new FormationManager(archerPrefab, transform.position + new Vector3(-2f, 1f, 0));
            //         _formationManager.SetFormationType(FormationManager.FormationType.Box);
            //         _formationManager.SetBoxParameters(archerCount, 1, false);
            //         _formationManager.UpdateFormation();
            //         Debug.Log($"生成 {archerCount} 个射手");
            //     }

            //     // 生成步兵
            //     GameObject infantryPrefab = Resources.Load<GameObject>("ShiBing");
            //     Debug.Log(infantryPrefab != null ? "成功加载步兵预制体" : "未找到步兵预制体");

            //     if (infantryPrefab != null && int.TryParse(troops[2], out int infantryCount))
            //     {
            //         _formationManager = new FormationManager(infantryPrefab, transform.position + new Vector3(-2f, -1f, 0));
            //         _formationManager.SetFormationType(FormationManager.FormationType.Box);
            //         _formationManager.SetBoxParameters(infantryCount, 1, false);
            //         _formationManager.UpdateFormation();
            //         Debug.Log($"生成 {infantryCount} 个步兵");
            //     }
            // }
            // else
            // {
            //     Debug.LogError($"兵力配置格式错误: {currentMessage["带多少兵"]}");
            // }

            // 处理目标位置
            string destination = currentMessage["去什么地方"];
            targetPosition = destination; // 更新目标位置变量
            currentPosition = transform.position.ToString(); // 更新当前位置

            // 使用新方法来更新目标位置
            UpdateTargetPosition(destination);

            // 处理状态转换
            string action = currentMessage["干什么事"];
            Debug.Log($"执行动作: {action}");
            switch (action)
            {
                case "Attack":
                    currentState = State.Attack;
                    break;
                case "Defend":
                    currentState = State.Defend;
                    break;
                case "Withdraw":
                    currentState = State.Withdraw;
                    break;
                case "Support":
                    currentState = State.Attack; // 支援也使用Attack状态
                    break;
                default:
                    Debug.LogError($"未知的动作类型: {action}");
                    break;
            }

            // 如果设置了目标位置但不是"当前位置"，确保处于可移动状态
            if (!string.IsNullOrEmpty(destination) && destination != "当前位置")
            {
                if (agent != null && agent.isActiveAndEnabled)
                {
                    agent.isStopped = false;
                    Debug.Log($"【曹操】设置为可移动状态，目标: {destination}");
                }
            }

            yield return new WaitForSeconds(0.5f);
        }
        else
        {
            Debug.Log("等待新的报文...");
        }

        yield return new WaitForSeconds(0.1f);
    }

    // 添加一个检查是否接近目的地的方法
    private bool CheckIfNearDestination()
    {
        // 如果没有设置目标位置，直接返回false
        if (string.IsNullOrEmpty(targetPosition))
        {
            return false;
        }

        // 查找目标游戏对象
        GameObject targetObj = GameObject.Find(targetPosition);
        if (targetObj == null) return false;

        float distanceToTarget = Vector3.Distance(transform.position, targetObj.transform.position);

        // 如果距离小于设定的阈值，认为已到达目的地
        if (distanceToTarget <= arrivalDistance)
        {
            if (!is_arrive)
            {
                is_arrive = true;
                Debug.Log($"【曹操】已接近目的地，距离: {distanceToTarget}，停止移动");
                // 停止导航，将代理速度设为0
                if (agent != null && agent.isActiveAndEnabled)
                {
                    agent.isStopped = true;
                    agent.velocity = Vector3.zero;
                }
                // 重置动画
                _animationController.SetMovement(Vector2.zero);
            }
            return true;
        }

        // 如果之前到达过，但现在又远离了（可能被其他力推开）
        if (is_arrive && distanceToTarget > arrivalDistance * 1.2f)
        {
            is_arrive = false;
            if (agent != null && agent.isActiveAndEnabled)
            {
                agent.isStopped = false;
            }
        }

        return false;
    }

    private IEnumerator AttackState()
    {
        Debug.Log($"【曹操】进入攻击状态，目标: {(enemyTransform != null ? enemyTransform.name : "未知")}");
        
        // 设置攻击相关参数
        if (agent != null && agent.isActiveAndEnabled)
        {
            agent.stoppingDistance = attackRange * 0.8f;
        }
        is_attacking = true;
        
        // 主攻击循环
        while (true)
        {
            // 1. 检查敌人是否有效
            if (enemyTransform == null || !enemyTransform.gameObject.activeInHierarchy)
            {
                Debug.Log($"【曹操】目标敌人不存在或已被击败，停止攻击状态");
                // 重置状态
                is_attacking = false;
                if (_animationController != null)
                {
                    _animationController.TriggerAttack(false);
                }
                // 切换回空闲状态
                currentState = State.Idle;
                yield break;
            }
            
            // 2. 检查距离
            float distanceToEnemy = Vector3.Distance(transform.position, enemyTransform.position);
            
            // 如果敌人超出检测范围，放弃追击
            if (distanceToEnemy > detectionRange * 1.2f)
            {
                Debug.Log($"【曹操】敌人已超出攻击范围，放弃追击");
                is_attacking = false;
                enemyTransform = null;
                if (_animationController != null)
                {
                    _animationController.TriggerAttack(false);
                }
                currentState = State.Idle;
                yield break;
            }
            
            // 3. 处理移动或攻击
            if (agent != null && agent.isActiveAndEnabled)
            {
                // 如果在攻击范围内
                if (distanceToEnemy <= attackRange)
                {
                    // 停止移动并面向敌人
                    agent.isStopped = true;
                    agent.velocity = Vector3.zero;
                    
                    // 如果攻击冷却结束，执行攻击
                    if (Time.time >= lastAttackTime + attackCooldown)
                    {
                        Debug.Log($"【曹操】攻击敌人: {enemyTransform.name}，距离: {distanceToEnemy:F2}");
                        
                        // 再次检查敌人是否有效（可能在移动过程中被击败）
                        if (enemyTransform == null || !enemyTransform.gameObject.activeInHierarchy)
                        {
                            Debug.Log($"【曹操】准备攻击时发现敌人已被击败，停止攻击");
                            is_attacking = false;
                            enemyTransform = null;
                            if (_animationController != null)
                            {
                                _animationController.TriggerAttack(false);
                            }
                            currentState = State.Idle;
                            yield break;
                        }
                        
                        // 执行攻击
                        if (_animationController != null)
                        {
                            _animationController.TriggerAttack(true);
                        }
                        PerformAttack();
                        lastAttackTime = Time.time;
                        
                        // 等待攻击动画播放
                        yield return new WaitForSeconds(attackCooldown * 0.5f);
                        
                        // 重置攻击动画
                        if (_animationController != null)
                        {
                            _animationController.TriggerAttack(false);
                        }
                        
                        // 攻击后短暂等待
                        yield return new WaitForSeconds(0.2f);
                    }
                }
                else
                {
                    // 如果不在攻击范围内，移动接近敌人
                    agent.isStopped = false;
                    agent.SetDestination(enemyTransform.position);
                    
                    // 更新移动动画
                    Vector2 velocity = new Vector2(agent.velocity.x, agent.velocity.y);
                    if (velocity.magnitude > 0.1f)
                    {
                        _animationController.SetMovement(velocity.normalized);
                    }
                    else
                    {
                        _animationController.SetMovement(Vector2.zero);
                    }
                    
                    // 移动过程中的短暂等待
                    yield return new WaitForSeconds(0.1f);
                }
            }
            
            // 短暂等待，避免每帧都执行
            yield return new WaitForSeconds(0.1f);
        }
    }

    private IEnumerator DefendState()
    {
        // 更新当前位置
        currentPosition = transform.position.ToString("F1");

        // 检查是否接近目的地
        CheckIfNearDestination();

        // 防守状态的行为逻辑
        _animationController.SetMovement(Vector2.zero);
        yield return new WaitForSeconds(0.5f);
    }

    private IEnumerator WithdrawState()
    {
        // 更新当前位置
        currentPosition = transform.position.ToString("F1");

        // 检查是否接近目的地
        if (CheckIfNearDestination())
        {
            yield return new WaitForSeconds(0.5f);
            yield break;
        }

        // 撤退状态下不攻击敌人，即使看到也继续撤退
        is_attacking = false;
        _animationController.TriggerAttack(false);

        // 检测是否有敌人靠近(仅为记录，不会攻击)
        GameObject targetEnemy = null;
        float nearestDist = Mathf.Infinity;
        GameObject[] enemies = GameObject.FindGameObjectsWithTag("Enemy");
        foreach (GameObject enemy in enemies)
        {
            float dist = Vector3.Distance(transform.position, enemy.transform.position);
            if (dist < nearestDist)
            {
                nearestDist = dist;
                targetEnemy = enemy;
            }
        }

        if (targetEnemy != null && nearestDist <= detectionRange)
        {
            Debug.Log($"【曹操】撤退中检测到敌人，距离: {nearestDist}，继续撤退！");
        }

        // 撤退状态的行为逻辑
        GameObject targetObj = GameObject.Find(targetPosition);
        if (targetObj != null)
        {
            agent.SetDestination(targetObj.transform.position);
        }

        Vector2 velocity = new Vector2(agent.velocity.x, agent.velocity.y);
        if (velocity.magnitude > 0.1f)
        {
            _animationController.SetMovement(velocity.normalized);
        }
        else
        {
            _animationController.SetMovement(Vector2.zero);
            // 到达目的地后，切换到Idle状态
            GameObject destObj = GameObject.Find(targetPosition);
            if (destObj != null && Vector3.Distance(transform.position, destObj.transform.position) < 1f)
            {
                currentState = State.Idle;
            }
        }
        yield return new WaitForSeconds(0.1f);
    }

    // 敌人检测协程
    private IEnumerator DetectEnemies()
    {
        Debug.Log("【曹操】启动敌人检测协程");
        while (true)
        {
            // 检查当前目标是否已经无效（被击败或禁用）
            if (enemyTransform != null && !enemyTransform.gameObject.activeInHierarchy)
            {
                Debug.Log($"【曹操】检测到当前目标敌人已被击败或不存在，重置目标");
                enemyTransform = null;
                is_attacking = false;
                
                // 重置攻击动画
                if (_animationController != null)
                {
                    _animationController.TriggerAttack(false);
                }
                
                // 如果当前状态是攻击状态，切换回空闲状态
                if (currentState == State.Attack)
                {
                    currentState = State.Idle;
                }
            }
            
            // 只有当不在攻击状态或者没有当前目标时才寻找新敌人
            if (currentState != State.Attack || enemyTransform == null)
            {
                Transform newEnemy = FindNearestEnemy();
                
                // 确保新找到的敌人是有效的且处于激活状态
                if (newEnemy != null && newEnemy.gameObject.activeInHierarchy)
                {
                    enemyTransform = newEnemy;
                    Debug.Log($"【曹操】发现敌人: {enemyTransform.name}，准备攻击!");
                    currentState = State.Attack;
                    is_attacking = true;
                }
            }

            yield return new WaitForSeconds(checkEnemyInterval);
        }
    }

    // 寻找最近的敌人
    private Transform FindNearestEnemy()
    {
        // 获取检测范围内的所有碰撞体
        Collider2D[] colliders = Physics2D.OverlapCircleAll(transform.position, detectionRange);

        Transform closestEnemy = null;
        float closestDistance = detectionRange;

        foreach (Collider2D collider in colliders)
        {
            // 忽略自己
            if (collider.gameObject == gameObject)
                continue;

            GameObject potentialEnemy = collider.gameObject;
            string enemyCountry = GetObjectCountry(potentialEnemy);

            // 如果有国家且不是己方国家，则视为敌人
            if (!string.IsNullOrEmpty(enemyCountry) && enemyCountry != country)
            {
                float distance = Vector2.Distance(transform.position, potentialEnemy.transform.position);
                if (distance < closestDistance)
                {
                    closestDistance = distance;
                    closestEnemy = potentialEnemy.transform;
                }
            }
        }

        return closestEnemy;
    }

    // 获取对象的国家
    private string GetObjectCountry(GameObject obj)
    {
        if (obj == null) return null;

        // 从标签判断是否是将军
        string tag = obj.tag;
        if (!string.IsNullOrEmpty(tag) && tag.Contains("_General"))
        {
            // 从标签获取国家信息
            if (tag.StartsWith("Wu_")) return "Wu";
            if (tag.StartsWith("Shu_")) return "Shu";
            if (tag.StartsWith("Wei_")) return "Wei";
        }

        // 判断是否是士兵
        ShiBing enemyShiBing = obj.GetComponent<ShiBing>();
        if (enemyShiBing != null && !string.IsNullOrEmpty(enemyShiBing.country))
        {
            return enemyShiBing.country;
        }

        // 判断其他具有country字段的对象
        MonoBehaviour[] components = obj.GetComponents<MonoBehaviour>();
        if (components != null)
        {
            foreach (MonoBehaviour comp in components)
            {
                if (comp == null) continue;

                try
                {
                    System.Reflection.FieldInfo field = comp.GetType().GetField("country");
                    if (field != null)
                    {
                        string country = (string)field.GetValue(comp);
                        if (!string.IsNullOrEmpty(country))
                        {
                            return country;
                        }
                    }
                }
                catch (System.Exception e)
                {
                    Debug.LogWarning($"获取国家属性时出错: {e.Message}");
                }
            }
        }

        return null;
    }

    // 执行攻击
    private void PerformAttack()
    {
        if (enemyTransform == null || !enemyTransform.gameObject.activeInHierarchy) return;

        Debug.Log($"【曹操】攻击 {enemyTransform.name}");

        // 对敌人造成伤害
        DealDamageToEnemy();
    }

    // 对敌人造成伤害
    private void DealDamageToEnemy()
    {
        if (enemyTransform == null) return;

        // 计算实际伤害值（可以添加随机浮动）
        int actualDamage = CalculateDamage();

        // 尝试对敌人造成伤害
        bool damageDealt = false;

        // 检查敌人是否是士兵
        ShiBing enemyShiBing = enemyTransform.GetComponent<ShiBing>();
        if (enemyShiBing != null)
        {
            enemyShiBing.TakeDamage(actualDamage);
            damageDealt = true;
        }

        // 检查敌人是否是吴国将军
        if (!damageDealt)
        {
            // 尝试获取各种将军组件
            MonoBehaviour enemyGeneral = enemyTransform.GetComponent<GanNing>();
            if (enemyGeneral == null) enemyGeneral = enemyTransform.GetComponent<LuXun>();
            if (enemyGeneral == null) enemyGeneral = enemyTransform.GetComponent<SunCe>();
            if (enemyGeneral == null) enemyGeneral = enemyTransform.GetComponent<SunShangXiang>();
            
            // 尝试获取蜀国将军组件
            if (enemyGeneral == null) enemyGeneral = enemyTransform.GetComponent<GuanYu>();
            if (enemyGeneral == null) enemyGeneral = enemyTransform.GetComponent<ZhangFei>();
            if (enemyGeneral == null) enemyGeneral = enemyTransform.GetComponent<HuangZhong>();
            
            // 尝试获取魏国将军组件
            if (enemyGeneral == null) enemyGeneral = enemyTransform.GetComponent<XiaHouDun>();
            if (enemyGeneral == null) enemyGeneral = enemyTransform.GetComponent<XuChu>();
            if (enemyGeneral == null) enemyGeneral = enemyTransform.GetComponent<XuHuang>();
            if (enemyGeneral == null) enemyGeneral = enemyTransform.GetComponent<CaoRen>();
            
            // 尝试获取主公组件
            if (enemyGeneral == null) enemyGeneral = enemyTransform.GetComponent<Wu_ZhuGong>();
            if (enemyGeneral == null) enemyGeneral = enemyTransform.GetComponent<Shu_ZhuGong>();
            
            if (enemyGeneral != null)
            {
                // 尝试直接调用将军的TakeDamage方法
                try
                {
                    var methodInfo = enemyGeneral.GetType().GetMethod("TakeDamage");
                    if (methodInfo != null)
                    {
                        methodInfo.Invoke(enemyGeneral, new object[] { actualDamage });
                        damageDealt = true;
                        Debug.Log($"【曹操】成功对将军 {enemyTransform.name} 造成伤害");
                    }
                }
                catch (System.Exception e)
                {
                    Debug.LogWarning($"尝试调用将军TakeDamage方法时出错: {e.Message}");
                }
            }
        }

        // 如果上述方法都未能造成伤害，尝试使用通用的方法
        if (!damageDealt)
        {
            try
            {
                // 最后尝试使用GameObject上的所有组件
                MonoBehaviour[] components = enemyTransform.GetComponents<MonoBehaviour>();
                foreach (MonoBehaviour comp in components)
                {
                    if (comp == null) continue;
                    
                    var methodInfo = comp.GetType().GetMethod("TakeDamage");
                    if (methodInfo != null)
                    {
                        methodInfo.Invoke(comp, new object[] { actualDamage });
                        damageDealt = true;
                        Debug.Log($"【曹操】通过通用方法对 {enemyTransform.name} 造成伤害");
                        break;
                    }
                }
            }
            catch (System.Exception e)
            {
                Debug.LogWarning($"尝试通用方法造成伤害时出错: {e.Message}");
            }
        }
        
        // 如果仍未能造成伤害，记录日志
        if (!damageDealt)
        {
            Debug.LogWarning($"【曹操】未能对 {enemyTransform.name} 造成伤害，可能缺少TakeDamage方法");
        }
    }

    // 计算实际伤害
    private int CalculateDamage()
    {
        // 基础伤害
        float baseDamage = attackPower;

        // 随机浮动 (±20%)
        float randomFactor = UnityEngine.Random.Range(0.8f, 1.2f);

        // 暴击判定 (15%几率)
        bool isCritical = UnityEngine.Random.value < 0.15f;
        float criticalMultiplier = isCritical ? 1.5f : 1.0f;

        // 计算最终伤害
        int finalDamage = Mathf.RoundToInt(baseDamage * randomFactor * criticalMultiplier);

        // 输出伤害日志
        if (isCritical)
        {
            Debug.Log($"【曹操】对 {enemyTransform.name} 造成了 <color=red>暴击</color> {finalDamage} 点伤害!");
        }
        else
        {
            Debug.Log($"【曹操】对 {enemyTransform.name} 造成了 {finalDamage} 点伤害");
        }

        return finalDamage;
    }

    // 受到伤害的处理方法
    public void TakeDamage(int damage)
    {
        // 确保生命值不会小于0
        health = Mathf.Max(0, health - damage);
        
        Debug.Log($"【曹操】受到 {damage} 点伤害，剩余生命值: {health}");
        
        // 播放受伤反馈
        StartCoroutine(FlashSprite());
        
        // 检查是否死亡
        if (health <= 0)
        {
            Die();
        }
    }
    
    // 死亡处理
    private void Die()
    {
        if (currentState == State.Dying) return; // 防止重复调用
        
        Debug.Log($"<color=red>【曹操】阵亡!</color>");
        
        // 将状态设置为死亡状态
        currentState = State.Dying;
        
        // 停止所有移动
        if (agent != null && agent.isActiveAndEnabled)
        {
            agent.isStopped = true;
            agent.velocity = Vector3.zero;
        }
        
        // 播放死亡动画
        if (_animationController != null)
        {
            _animationController.TriggerDeath();
        }
        
        // 延迟禁用游戏对象
        StartCoroutine(DisableAfterDeath());
    }
    
    // 短暂闪烁效果（受伤反馈）
    private IEnumerator FlashSprite()
    {
        SpriteRenderer spriteRenderer = GetComponent<SpriteRenderer>();
        if (spriteRenderer != null)
        {
            Color originalColor = spriteRenderer.color;
            spriteRenderer.color = Color.red;
            yield return new WaitForSeconds(0.1f);
            spriteRenderer.color = originalColor;
        }
    }
    
    // 死亡后禁用游戏对象
    private IEnumerator DisableAfterDeath()
    {
        // 等待死亡动画播放
        yield return new WaitForSeconds(2f);
        
        // 禁用游戏对象
        gameObject.SetActive(false);
    }
}